package org.linlinjava.litemall.db.service;

import com.github.pagehelper.PageHelper;
import org.linlinjava.litemall.db.dao.LitemallPointsRecordMapper;
import org.linlinjava.litemall.db.domain.LitemallOrder;
import org.linlinjava.litemall.db.domain.LitemallPointsRecord;
import org.linlinjava.litemall.db.domain.LitemallUser;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.RequestParam;

import javax.annotation.Resource;
import java.beans.Transient;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

@Service
public class LitemallPointsRecordService {

    @Autowired
    private LitemallPointsRecordMapper pointsRecordMapper;

    @Autowired
    private LitemallUserService service;

    public int add(LitemallPointsRecord record){
        return pointsRecordMapper.insert(record);
    }

    public List<LitemallPointsRecord> queryList(int page,int size,int userId,int type){
        LitemallPointsRecord point = new LitemallPointsRecord();
        point.setUserId(userId);
        PageHelper.startPage(page, size);

        if (type == 0){
            return pointsRecordMapper.selectByPage(point);
        }else {
            return pointsRecordMapper.selectAllByPage(point);
        }



    }

    /**
     * 转让积分
     * @param fromId    从哪位id的用户转出
     * @param integral  转出的积分
     * @param mobile    转入的用户手机号
     * @throws Exception
     */
    @Transactional
    public void transfer(Integer fromId, Double integral, String mobile) throws Exception {
        integral = this.handleIntegral(integral);
        LitemallUser fromUser = service.findById(fromId); // 转出积分的用户
        LitemallUser toUser = service.GetByUsermobile(mobile); // 转入积分的用户
        if(fromUser != null && toUser != null){ // 如果两位用户都可以找到，可以对两位做积分操作
            if (fromUser.getIntegral() - integral >= 0) {
                fromUser.setIntegral(fromUser.getIntegral() - integral); // 转出用户减去转出的积分
            } else {
                //integral = fromUser.getIntegral();
                //fromUser.setIntegral(0d); // 转出用户减去转出的积分
                throw new Exception("积分余额不足");
            }
            toUser.setIntegral(toUser.getIntegral() + integral); // 转入用户添加转入的积分
            service.updateById(toUser); // 将两位用户进行保存
            service.updateById(fromUser);

            // 接下来是往基本分调价积分的变动记录
            // 首先是转出积分的记录
            LitemallPointsRecord from = new LitemallPointsRecord();
            from.setUserId(fromId); // 设置受影响对象
            from.setIntegral(integral); // 设置积分变动额度
            from.setType(0); // 设置积分变动类型
            from.setRemark("id为【" + fromId + "】的用户【积分转出】 " + integral + " ，目标是id为【"+toUser.getId()+"】的用户"); // 设置备注，描述积分变动详情
            from.setCreateTime(LocalDateTime.now()); // 设置添加时间
            from.setYhk("0");
            from.setYhklx("0");
            from.setFromUserId(toUser.getId());
            this.add(from); // 添加这次加分变动记录

            // 积分转入记录
            LitemallPointsRecord to = new LitemallPointsRecord();
            to.setUserId(toUser.getId()); // 设置积分转入受影响的用户
            to.setIntegral(integral); // 设置转入积分数目
            to.setType(4); // 设置类型
            to.setRemark("id为【" + toUser.getId() + "】的用户得到了id为【" + fromId + "】的用户【积分转入】的  " + integral);// 设置备注，描述积分变动详情
            to.setCreateTime(LocalDateTime.now());
            to.setYhk("0");
            to.setYhklx("0");
            to.setFromUserId(fromId);
            this.add(to);
        } else {
            throw new Exception("用户信息异常，操作失败");
        }
    }

    /**
     * 推荐人奖励的方法
     * @param toUserId      推荐人id
     * @param fromUserId    被哪位用户影响的id
     * @param integral      增加积分
     * @param order         订单实体类
     * @param inviteeType   直接邀请人还是间接邀请人
     */
    public void inviteeReward(Integer toUserId,Integer fromUserId, Double integral, LitemallOrder order, String inviteeType){
        integral = this.handleIntegral(integral);
        String remark = "";
        if ("1".equals(inviteeType)) {
            remark = "id为【" + toUserId + "】的用户因直接推荐获得了【系统奖励】的" + integral + "来源于id为【"+fromUserId+"】的用户，订单号为："+order.getOrderSn();
        } else {
            remark = "id为【" + toUserId + "】的用户因间接推荐获得了【系统奖励】的" + integral + "来源于id为【"+fromUserId+"】的用户，订单号为："+order.getOrderSn();
        }
        this.reward(toUserId,fromUserId, integral, order, remark);
    }

    /**
     * 区域代理奖励
     * @param toUserId      代理人id
     * @param fromUserId    受哪位用户影响的id
     * @param integral      增加的积分
     * @param order         订单实体类
     * @param proxyType     代理类型
     */
    public void proxyReward(Integer toUserId,Integer fromUserId, Double integral, LitemallOrder order, String proxyType) {
        integral = this.handleIntegral(integral);
        String remark = "";
        if ("1".equals(proxyType)) {
            remark = "id为【" + toUserId + "】的用户因省级代理获得了【系统奖励】的" + integral + "来源于id为【"+fromUserId+"】的用户，订单号为："+order.getOrderSn();
        } else if ("2".equals(proxyType)) {
            remark = "id为【" + toUserId + "】的用户因市级代理获得了【系统奖励】的" + integral + "来源于id为【"+fromUserId+"】的用户，订单号为："+order.getOrderSn();
        } else {
            remark = "id为【" + toUserId + "】的用户因县级代理获得了【系统奖励】的" + integral + "来源于id为【"+fromUserId+"】的用户，订单号为："+order.getOrderSn();
        }
        this.reward(toUserId,fromUserId, integral, order, remark);
    }

    /**
     * 记录奖励积分
     * @param userId    受影响的用户id
     * @param integral  积分变动数
     * @param remark    系统奖励也要被备注详情
     */
    public void reward(Integer userId,Integer fromUserId, Double integral, LitemallOrder order, String remark) {
        LitemallPointsRecord from = new LitemallPointsRecord();
        from.setUserId(userId); // 设置受影响的用户
        from.setIntegral(integral); // 设置积分变动额度
        from.setType(1); // 设置类型
        from.setRemark(remark); // 设置详情
        from.setCreateTime(LocalDateTime.now());
        from.setYhk("0");
        from.setYhklx("0");
        from.setFromUserId(fromUserId);
        from.setOrderSn(order.getOrderSn());
        this.add(from);
    }
    // 保留两位小数
    public double handleIntegral(double integral){
        BigDecimal bg = new BigDecimal(integral).setScale(2, RoundingMode.DOWN);
        return bg.doubleValue();
    }


    /**
     * 积分提现
     * @param userId    提现的用户
     * @param integral  体现积分的额度
     * @throws Exception
     */
    public void withdrawal(Integer userId, Double integral,String yhk,String yhklx,String remark) throws Exception {
        integral = this.handleIntegral(integral);
        LitemallUser user = service.findById(userId);
        if (user != null) {
            Double userInteg = user.getIntegral();
            if (userInteg >= integral) { // 判断用户当前的积分是否大于等于去要扣除的积分，大于就正常减运算
                userInteg -= integral;
                user.setIntegral(userInteg);
            } else { // 不大于就直接将当前的用户积分置0，已扣除
                //user.setIntegral(0d);
                //integral = userInteg;
                throw new Exception("提现失败，可提现余额不足");
            }
            service.updateById(user);
            LitemallPointsRecord from = new LitemallPointsRecord();
            from.setUserId(userId);
            from.setIntegral(integral);
            from.setType(2); // 提现
            from.setCreateTime(LocalDateTime.now());
            from.setYhk(yhk);
            from.setYhklx(yhklx);
            from.setRemark("id为【" + userId + "】的用户【积分提现】了" + integral + ";" + remark);
            this.add(from);
        } else {
            throw new Exception("用户信息异常，操作失败");
        }
    }

    /**
     * 后台设置积分
     * @param userId    被设置的用户
     * @param integral  设置好的积分 负数表示减
     * @throws Exception
     */
    public void setting(Integer userId, Double integral){
        integral = this.handleIntegral(integral);

        LitemallPointsRecord from = new LitemallPointsRecord();
        from.setUserId(userId);

        String remark = "";
        if (integral > 0){
            from.setType(3);// 增加积分
            remark = "id为【" + userId + "】的用户积分增加了" + integral;
        }else {
            from.setType(10); // 减少积分
            integral = integral * -1;
            remark = "id为【" + userId + "】的用户积分减少了" + integral;
        }
        from.setIntegral(integral);
        from.setRemark(remark);
        from.setCreateTime(LocalDateTime.now());
        from.setYhk("0");
        from.setYhklx("0");
        this.add(from);
    }

    /**
     * 利用积分支付
     * @param userId    操作的用户
     * @param integral  花费多少积分
     */
    public void pay(Integer userId, Double integral, LitemallOrder order) {
        integral = this.handleIntegral(integral);
        LitemallPointsRecord from = new LitemallPointsRecord();
        from.setUserId(userId);
        from.setIntegral(integral);
        from.setType(5); // 积分支付
        from.setRemark("id为【" + userId + "】的用户使用【积分支付】了" + integral);
        from.setCreateTime(LocalDateTime.now());
        from.setOrderSn(order.getOrderSn());
        from.setYhk("0");
        from.setYhklx("0");
        this.add(from);

    }


    public List<LitemallPointsRecord> selectPointListByType(Integer userId, Integer type) {
        LitemallPointsRecord queryEntity = new LitemallPointsRecord();
        queryEntity.setUserId(userId);
        queryEntity.setType(type);
        return pointsRecordMapper.selectPointListByType(queryEntity);
    }

    public static void main(String[] args) {
        LocalDateTime time2 = new Date().toInstant().atZone(ZoneId.of("+8")).toLocalDateTime();
        System.out.println(time2);
    }

}
